home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 July: Mac OS SDK / Dev.CD Jul 99 SDK1.toast / Development Kits / Mac OS / Interfaces&Libraries / Universal / Interfaces / PInterfaces / PPCToolbox.p < prev    next >
Encoding:
Text File  |  1998-08-17  |  18.6 KB  |  501 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        PPCToolbox.p
  3.  
  4.      Contains:    Program-Program Communications Toolbox Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.2
  8.  
  9.      Copyright:    © 1989-1993, 1995-1998 by Apple Computer, Inc., all rights reserved
  10.  
  11.      Bugs?:        For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. }
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT PPCToolbox;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __PPCTOOLBOX__}
  27. {$SETC __PPCTOOLBOX__ := 1}
  28.  
  29. {$I+}
  30. {$SETC PPCToolboxIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33. {$IFC UNDEFINED __MACTYPES__}
  34. {$I MacTypes.p}
  35. {$ENDC}
  36. {$IFC UNDEFINED __APPLETALK__}
  37. {$I AppleTalk.p}
  38. {$ENDC}
  39.  
  40.  
  41. {$PUSH}
  42. {$ALIGN MAC68K}
  43. {$LibExport+}
  44.  
  45.  
  46. TYPE
  47.     PPCServiceType                        = UInt8;
  48.  
  49. CONST
  50.     ppcServiceRealTime            = 1;
  51.  
  52.  
  53. TYPE
  54.     PPCLocationKind                        = INTEGER;
  55.  
  56. CONST
  57.     ppcNoLocation                = 0;                            {  There is no PPCLocName  }
  58.     ppcNBPLocation                = 1;                            {  Use AppleTalk NBP       }
  59.     ppcNBPTypeLocation            = 2;                            {  Used for specifying a location name type during PPCOpen only  }
  60.  
  61.  
  62. TYPE
  63.     PPCPortKinds                        = INTEGER;
  64.  
  65. CONST
  66.     ppcByCreatorAndType            = 1;                            {  Port type is specified as colloquial Mac creator and type  }
  67.     ppcByString                    = 2;                            {  Port type is in pascal string format  }
  68.  
  69. { Values returned for request field in PPCInform call }
  70.  
  71. TYPE
  72.     PPCSessionOrigin                    = UInt8;
  73.  
  74. CONST
  75.                                                                 {  Values returned for requestType field in PPCInform call  }
  76.     ppcLocalOrigin                = 1;                            {  session originated from this machine  }
  77.     ppcRemoteOrigin                = 2;                            {  session originated from remote machine  }
  78.  
  79.  
  80. TYPE
  81.     PPCPortRefNum                        = INTEGER;
  82.     PPCSessRefNum                        = LONGINT;
  83.     PPCPortRecPtr = ^PPCPortRec;
  84.     PPCPortRec = RECORD
  85.         nameScript:                ScriptCode;                                {  script of name  }
  86.         name:                    Str32Field;                                {  name of port as seen in browser  }
  87.         portKindSelector:        PPCPortKinds;                            {  which variant  }
  88.         CASE INTEGER OF
  89.         0: (
  90.             portTypeStr:        Str32;                                    {  pascal type string  }
  91.             );
  92.         1: (
  93.             portCreator:        OSType;
  94.             portType:            OSType;
  95.            );
  96.     END;
  97.  
  98.     PPCPortPtr                            = ^PPCPortRec;
  99.     LocationNameRecPtr = ^LocationNameRec;
  100.     LocationNameRec = RECORD
  101.         locationKindSelector:    PPCLocationKind;                        {  which variant  }
  102.         CASE INTEGER OF
  103.         0: (
  104.             nbpEntity:            EntityName;                                {  NBP name entity  }
  105.             );
  106.         1: (
  107.             nbpType:            Str32;                                    {  just the NBP type string, for PPCOpen  }
  108.             );
  109.     END;
  110.  
  111.     LocationNamePtr                        = ^LocationNameRec;
  112.     PortInfoRecPtr = ^PortInfoRec;
  113.     PortInfoRec = RECORD
  114.         filler1:                SInt8;
  115.         authRequired:            BOOLEAN;
  116.         name:                    PPCPortRec;
  117.     END;
  118.  
  119.     PortInfoPtr                            = ^PortInfoRec;
  120.     PortInfoArrayPtr                    = ^PortInfoRec;
  121.     PPCParamBlockRecPtr = ^PPCParamBlockRec;
  122.     PPCParamBlockPtr                    = ^PPCParamBlockRec;
  123. {$IFC TYPED_FUNCTION_POINTERS}
  124.     PPCCompProcPtr = PROCEDURE(pb: PPCParamBlockPtr);
  125. {$ELSEC}
  126.     PPCCompProcPtr = ProcPtr;
  127. {$ENDC}
  128.  
  129.     PPCCompUPP = UniversalProcPtr;
  130.     PPCOpenPBRecPtr = ^PPCOpenPBRec;
  131.     PPCOpenPBRec = PACKED RECORD
  132.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  133.         csCode:                    UInt16;                                    {  Requested PPC command  }
  134.         intUse:                    UInt16;                                    {  Internal Use  }
  135.         intUsePtr:                Ptr;                                    {  Internal Use  }
  136.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  137.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  138.         Reserved:                ARRAY [0..4] OF UInt32;                    {  Reserved for PPC, Don't use  }
  139.         portRefNum:                PPCPortRefNum;                            {  38 <--   Port Reference  }
  140.         filler1:                LONGINT;
  141.         serviceType:            PPCServiceType;                            {  44 -->    Bit field describing the requested port service  }
  142.         resFlag:                UInt8;                                    {  Must be set to 0  }
  143.         portName:                PPCPortPtr;                                {  46 -->   PortName for PPC  }
  144.         locationName:            LocationNamePtr;                        {  50 -->   If NBP Registration is required  }
  145.         networkVisible:            BOOLEAN;                                {  54 -->   make this network visible on network  }
  146.         nbpRegistered:            BOOLEAN;                                {  55 <--   The given location name was registered on the network  }
  147.     END;
  148.  
  149.     PPCOpenPBPtr                        = ^PPCOpenPBRec;
  150.     PPCInformPBRecPtr = ^PPCInformPBRec;
  151.     PPCInformPBRec = PACKED RECORD
  152.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  153.         csCode:                    UInt16;                                    {  Requested PPC command  }
  154.         intUse:                    UInt16;                                    {  Internal Use  }
  155.         intUsePtr:                Ptr;                                    {  Internal Use  }
  156.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  157.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  158.         Reserved:                ARRAY [0..4] OF UInt32;                    {  Reserved for PPC, Don't use  }
  159.         portRefNum:                PPCPortRefNum;                            {  38 -->   Port Identifier  }
  160.         sessRefNum:                PPCSessRefNum;                            {  40 <--   Session Reference  }
  161.         serviceType:            PPCServiceType;                            {  44 <--   Status Flags for type of session, local, remote  }
  162.         autoAccept:                BOOLEAN;                                {  45 -->   if true session will be accepted automatically  }
  163.         portName:                PPCPortPtr;                                {  46 -->   Buffer for Source PPCPortRec  }
  164.         locationName:            LocationNamePtr;                        {  50 -->   Buffer for Source LocationNameRec  }
  165.         userName:                StringPtr;                                {  54 -->   Buffer for Soure user's name trying to link.  }
  166.         userData:                UInt32;                                    {  58 <--   value included in PPCStart's userData  }
  167.         requestType:            PPCSessionOrigin;                        {  62 <--   Local or Network  }
  168.         filler:                    SInt8;
  169.     END;
  170.  
  171.     PPCInformPBPtr                        = ^PPCInformPBRec;
  172.     PPCStartPBRecPtr = ^PPCStartPBRec;
  173.     PPCStartPBRec = PACKED RECORD
  174.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  175.         csCode:                    UInt16;                                    {  Requested PPC command  }
  176.         intUse:                    UInt16;                                    {  Internal Use  }
  177.         intUsePtr:                Ptr;                                    {  Internal Use  }
  178.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  179.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  180.         Reserved:                ARRAY [0..4] OF UInt32;                    {  Reserved for PPC, Don't use  }
  181.         portRefNum:                PPCPortRefNum;                            {  38 -->   Port Identifier  }
  182.         sessRefNum:                PPCSessRefNum;                            {  40 <--   Session Reference  }
  183.         serviceType:            PPCServiceType;                            {  44 <--   Actual service method (realTime)  }
  184.         resFlag:                UInt8;                                    {  45 -->   Must be set to 0   }
  185.         portName:                PPCPortPtr;                                {  46 -->   Destination portName  }
  186.         locationName:            LocationNamePtr;                        {  50 -->   NBP or NAS style service location name  }
  187.         rejectInfo:                UInt32;                                    {  54 <--   reason for rejecting the session request  }
  188.         userData:                UInt32;                                    {  58 -->   Copied to destination PPCInform parameter block  }
  189.         userRefNum:                UInt32;                                    {  62 -->   userRefNum (obtained during login process)   }
  190.     END;
  191.  
  192.     PPCStartPBPtr                        = ^PPCStartPBRec;
  193.     PPCAcceptPBRecPtr = ^PPCAcceptPBRec;
  194.     PPCAcceptPBRec = RECORD
  195.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  196.         csCode:                    UInt16;                                    {  Requested PPC command  }
  197.         intUse:                    UInt16;                                    {  Internal Use  }
  198.         intUsePtr:                Ptr;                                    {  Internal Use  }
  199.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  200.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  201.         Reserved:                ARRAY [0..4] OF UInt32;                    {  Reserved for PPC, Don't use  }
  202.         filler1:                INTEGER;
  203.         sessRefNum:                PPCSessRefNum;                            {  40 -->   Session Reference  }
  204.     END;
  205.  
  206.     PPCAcceptPBPtr                        = ^PPCAcceptPBRec;
  207.     PPCRejectPBRecPtr = ^PPCRejectPBRec;
  208.     PPCRejectPBRec = RECORD
  209.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  210.         csCode:                    UInt16;                                    {  Requested PPC command  }
  211.         intUse:                    UInt16;                                    {  Internal Use  }
  212.         intUsePtr:                Ptr;                                    {  Internal Use  }
  213.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  214.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  215.         Reserved:                ARRAY [0..4] OF UInt32;                    {  Reserved for PPC, Don't use  }
  216.         filler1:                INTEGER;
  217.         sessRefNum:                PPCSessRefNum;                            {  40 -->   Session Reference  }
  218.         filler2:                INTEGER;
  219.         filler3:                LONGINT;
  220.         filler4:                LONGINT;
  221.         rejectInfo:                UInt32;                                    {  54 -->   reason for rejecting the session request   }
  222.     END;
  223.  
  224.     PPCRejectPBPtr                        = ^PPCRejectPBRec;
  225.     PPCWritePBRecPtr = ^PPCWritePBRec;
  226.     PPCWritePBRec = RECORD
  227.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  228.         csCode:                    UInt16;                                    {  Requested PPC command  }
  229.         intUse:                    UInt16;                                    {  Internal Use  }
  230.         intUsePtr:                Ptr;                                    {  Internal Use  }
  231.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  232.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  233.         Reserved:                ARRAY [0..4] OF UInt32;                    {  Reserved for PPC, Don't use  }
  234.         filler1:                INTEGER;
  235.         sessRefNum:                PPCSessRefNum;                            {  40 -->   Session Reference  }
  236.         bufferLength:            Size;                                    {  44 -->   Length of the message buffer  }
  237.         actualLength:            Size;                                    {  48 <--   Actual Length Written  }
  238.         bufferPtr:                Ptr;                                    {  52 -->   Pointer to message buffer  }
  239.         more:                    BOOLEAN;                                {  56 -->   if more data in this block will be written  }
  240.         filler2:                SInt8;
  241.         userData:                UInt32;                                    {  58 -->   Message block userData Uninterpreted by PPC  }
  242.         blockCreator:            OSType;                                    {  62 -->   Message block creator Uninterpreted by PPC  }
  243.         blockType:                OSType;                                    {  66 -->   Message block type Uninterpreted by PPC  }
  244.     END;
  245.  
  246.     PPCWritePBPtr                        = ^PPCWritePBRec;
  247.     PPCReadPBRecPtr = ^PPCReadPBRec;
  248.     PPCReadPBRec = RECORD
  249.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  250.         csCode:                    UInt16;                                    {  Requested PPC command  }
  251.         intUse:                    UInt16;                                    {  Internal Use  }
  252.         intUsePtr:                Ptr;                                    {  Internal Use  }
  253.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  254.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  255.         Reserved:                ARRAY [0..4] OF UInt32;                    {  Reserved for PPC, Don't use  }
  256.         filler1:                INTEGER;
  257.         sessRefNum:                PPCSessRefNum;                            {  40 -->   Session Reference  }
  258.         bufferLength:            Size;                                    {  44 -->   Length of the message buffer  }
  259.         actualLength:            Size;                                    {  48 <--   Actual length read  }
  260.         bufferPtr:                Ptr;                                    {  52 -->   Pointer to message buffer  }
  261.         more:                    BOOLEAN;                                {  56 <--   if true more data in this block to be read  }
  262.         filler2:                SInt8;
  263.         userData:                UInt32;                                    {  58 <--   Message block userData Uninterpreted by PPC  }
  264.         blockCreator:            OSType;                                    {  62 <--   Message block creator Uninterpreted by PPC  }
  265.         blockType:                OSType;                                    {  66 <--   Message block type Uninterpreted by PPC  }
  266.     END;
  267.  
  268.     PPCReadPBPtr                        = ^PPCReadPBRec;
  269.     PPCEndPBRecPtr = ^PPCEndPBRec;
  270.     PPCEndPBRec = RECORD
  271.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  272.         csCode:                    UInt16;                                    {  Requested PPC command  }
  273.         intUse:                    UInt16;                                    {  Internal Use  }
  274.         intUsePtr:                Ptr;                                    {  Internal Use  }
  275.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  276.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  277.         Reserved:                ARRAY [0..4] OF UInt32;                    {  Reserved for PPC, Don't use  }
  278.         filler1:                INTEGER;
  279.         sessRefNum:                PPCSessRefNum;                            {  40 -->   Session Reference  }
  280.     END;
  281.  
  282.     PPCEndPBPtr                            = ^PPCEndPBRec;
  283.     PPCClosePBRecPtr = ^PPCClosePBRec;
  284.     PPCClosePBRec = RECORD
  285.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  286.         csCode:                    UInt16;                                    {  Requested PPC command  }
  287.         intUse:                    UInt16;                                    {  Internal Use  }
  288.         intUsePtr:                Ptr;                                    {  Internal Use  }
  289.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  290.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  291.         Reserved:                ARRAY [0..4] OF UInt32;                    {  Reserved for PPC, Don't use  }
  292.         portRefNum:                PPCPortRefNum;                            {  38 -->   Port Identifier  }
  293.     END;
  294.  
  295.     PPCClosePBPtr                        = ^PPCClosePBRec;
  296.     IPCListPortsPBRecPtr = ^IPCListPortsPBRec;
  297.     IPCListPortsPBRec = RECORD
  298.         qLink:                    Ptr;                                    {  PPC's Internal Use  }
  299.         csCode:                    UInt16;                                    {  Requested PPC command  }
  300.         intUse:                    UInt16;                                    {  Internal Use  }
  301.         intUsePtr:                Ptr;                                    {  Internal Use  }
  302.         ioCompletion:            PPCCompUPP;                                {  12 -->    Completion Routine  }
  303.         ioResult:                OSErr;                                    {  16 <--     Command Result Code  }
  304.         Reserved:                ARRAY [0..4] OF UInt32;                    {  Reserved for PPC, Don't use  }
  305.         filler1:                INTEGER;
  306.         startIndex:                UInt16;                                    {  40 -->   Start Index  }
  307.         requestCount:            UInt16;                                    {  42 -->   Number of entries to be returned  }
  308.         actualCount:            UInt16;                                    {  44 <--   Actual Number of entries to be returned  }
  309.         portName:                PPCPortPtr;                                {  46 -->   PortName Match  }
  310.         locationName:            LocationNamePtr;                        {  50 -->   NBP or NAS type name to locate the Port Location  }
  311.         bufferPtr:                PortInfoArrayPtr;                        {  54 -->   Pointer to a buffer requestCount*sizeof(PortInfo) bytes big  }
  312.     END;
  313.  
  314.     IPCListPortsPBPtr                    = ^IPCListPortsPBRec;
  315.     PPCParamBlockRec = RECORD
  316.         CASE INTEGER OF
  317.         0: (
  318.             openParam:            PPCOpenPBRec;
  319.             );
  320.         1: (
  321.             informParam:        PPCInformPBRec;
  322.             );
  323.         2: (
  324.             startParam:            PPCStartPBRec;
  325.             );
  326.         3: (
  327.             acceptParam:        PPCAcceptPBRec;
  328.             );
  329.         4: (
  330.             rejectParam:        PPCRejectPBRec;
  331.             );
  332.         5: (
  333.             writeParam:            PPCWritePBRec;
  334.             );
  335.         6: (
  336.             readParam:            PPCReadPBRec;
  337.             );
  338.         7: (
  339.             endParam:            PPCEndPBRec;
  340.             );
  341.         8: (
  342.             closeParam:            PPCClosePBRec;
  343.             );
  344.         9: (
  345.             listPortsParam:        IPCListPortsPBRec;
  346.             );
  347.     END;
  348.  
  349. {  PPC Calling Conventions  }
  350. FUNCTION PPCInit: OSErr;
  351.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  352.     INLINE $7000, $A0DD, $3E80;
  353.     {$ENDC}
  354.  
  355. FUNCTION PPCOpenSync(pb: PPCOpenPBPtr): OSErr;
  356.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  357.     INLINE $205F, $7001, $A0DD, $3E80;
  358.     {$ENDC}
  359. FUNCTION PPCOpenAsync(pb: PPCOpenPBPtr): OSErr;
  360.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  361.     INLINE $205F, $7001, $A4DD, $3E80;
  362.     {$ENDC}
  363. FUNCTION PPCInformSync(pb: PPCInformPBPtr): OSErr;
  364.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  365.     INLINE $205F, $7003, $A0DD, $3E80;
  366.     {$ENDC}
  367. FUNCTION PPCInformAsync(pb: PPCInformPBPtr): OSErr;
  368.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  369.     INLINE $205F, $7003, $A4DD, $3E80;
  370.     {$ENDC}
  371. FUNCTION PPCStartSync(pb: PPCStartPBPtr): OSErr;
  372.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  373.     INLINE $205F, $7002, $A0DD, $3E80;
  374.     {$ENDC}
  375. FUNCTION PPCStartAsync(pb: PPCStartPBPtr): OSErr;
  376.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  377.     INLINE $205F, $7002, $A4DD, $3E80;
  378.     {$ENDC}
  379. FUNCTION PPCAcceptSync(pb: PPCAcceptPBPtr): OSErr;
  380.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  381.     INLINE $205F, $7004, $A0DD, $3E80;
  382.     {$ENDC}
  383. FUNCTION PPCAcceptAsync(pb: PPCAcceptPBPtr): OSErr;
  384.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  385.     INLINE $205F, $7004, $A4DD, $3E80;
  386.     {$ENDC}
  387. FUNCTION PPCRejectSync(pb: PPCRejectPBPtr): OSErr;
  388.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  389.     INLINE $205F, $7005, $A0DD, $3E80;
  390.     {$ENDC}
  391. FUNCTION PPCRejectAsync(pb: PPCRejectPBPtr): OSErr;
  392.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  393.     INLINE $205F, $7005, $A4DD, $3E80;
  394.     {$ENDC}
  395. FUNCTION PPCWriteSync(pb: PPCWritePBPtr): OSErr;
  396.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  397.     INLINE $205F, $7006, $A0DD, $3E80;
  398.     {$ENDC}
  399. FUNCTION PPCWriteAsync(pb: PPCWritePBPtr): OSErr;
  400.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  401.     INLINE $205F, $7006, $A4DD, $3E80;
  402.     {$ENDC}
  403. FUNCTION PPCReadSync(pb: PPCReadPBPtr): OSErr;
  404.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  405.     INLINE $205F, $7007, $A0DD, $3E80;
  406.     {$ENDC}
  407. FUNCTION PPCReadAsync(pb: PPCReadPBPtr): OSErr;
  408.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  409.     INLINE $205F, $7007, $A4DD, $3E80;
  410.     {$ENDC}
  411. FUNCTION PPCEndSync(pb: PPCEndPBPtr): OSErr;
  412.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  413.     INLINE $205F, $7008, $A0DD, $3E80;
  414.     {$ENDC}
  415. FUNCTION PPCEndAsync(pb: PPCEndPBPtr): OSErr;
  416.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  417.     INLINE $205F, $7008, $A4DD, $3E80;
  418.     {$ENDC}
  419. FUNCTION PPCCloseSync(pb: PPCClosePBPtr): OSErr;
  420.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  421.     INLINE $205F, $7009, $A0DD, $3E80;
  422.     {$ENDC}
  423. FUNCTION PPCCloseAsync(pb: PPCClosePBPtr): OSErr;
  424.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  425.     INLINE $205F, $7009, $A4DD, $3E80;
  426.     {$ENDC}
  427. FUNCTION IPCListPortsSync(pb: IPCListPortsPBPtr): OSErr;
  428.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  429.     INLINE $205F, $700A, $A0DD, $3E80;
  430.     {$ENDC}
  431. FUNCTION IPCListPortsAsync(pb: IPCListPortsPBPtr): OSErr;
  432.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  433.     INLINE $205F, $700A, $A4DD, $3E80;
  434.     {$ENDC}
  435. FUNCTION DeleteUserIdentity(userRef: UInt32): OSErr;
  436. FUNCTION GetDefaultUser(VAR userRef: UInt32; VAR userName: Str32): OSErr;
  437. FUNCTION StartSecureSession(pb: PPCStartPBPtr; VAR userName: Str32; useDefault: BOOLEAN; allowGuest: BOOLEAN; VAR guestSelected: BOOLEAN; prompt: Str255): OSErr;
  438.  
  439. TYPE
  440. {$IFC TYPED_FUNCTION_POINTERS}
  441.     PPCFilterProcPtr = FUNCTION(name: LocationNamePtr; port: PortInfoPtr): BOOLEAN;
  442. {$ELSEC}
  443.     PPCFilterProcPtr = ProcPtr;
  444. {$ENDC}
  445.  
  446.     PPCFilterUPP = UniversalProcPtr;
  447.  
  448. CONST
  449.     uppPPCCompProcInfo = $000000C0;
  450.     uppPPCFilterProcInfo = $000003D0;
  451.  
  452. FUNCTION NewPPCCompProc(userRoutine: PPCCompProcPtr): PPCCompUPP;
  453.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  454.     INLINE $2E9F;
  455.     {$ENDC}
  456.  
  457. FUNCTION NewPPCFilterProc(userRoutine: PPCFilterProcPtr): PPCFilterUPP;
  458.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  459.     INLINE $2E9F;
  460.     {$ENDC}
  461.  
  462. PROCEDURE CallPPCCompProc(pb: PPCParamBlockPtr; userRoutine: PPCCompUPP);
  463.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  464.     INLINE $205F, $4E90;
  465.     {$ENDC}
  466.  
  467. FUNCTION CallPPCFilterProc(name: LocationNamePtr; port: PortInfoPtr; userRoutine: PPCFilterUPP): BOOLEAN;
  468.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  469.     INLINE $205F, $4E90;
  470.     {$ENDC}
  471. FUNCTION PPCBrowser(prompt: Str255; applListLabel: Str255; defaultSpecified: BOOLEAN; VAR theLocation: LocationNameRec; VAR thePortInfo: PortInfoRec; portFilter: PPCFilterUPP; theLocNBPType: Str32): OSErr;
  472.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  473.     INLINE $303C, $0D00, $A82B;
  474.     {$ENDC}
  475.  
  476. {
  477.   The ParamBlock calls with the "Sync" or "Async" suffix are being phased out.
  478. }
  479. FUNCTION PPCOpen(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  480. FUNCTION PPCInform(pb: PPCInformPBPtr; async: BOOLEAN): OSErr;
  481. FUNCTION PPCStart(pb: PPCStartPBPtr; async: BOOLEAN): OSErr;
  482. FUNCTION PPCAccept(pb: PPCAcceptPBPtr; async: BOOLEAN): OSErr;
  483. FUNCTION PPCReject(pb: PPCRejectPBPtr; async: BOOLEAN): OSErr;
  484. FUNCTION PPCWrite(pb: PPCWritePBPtr; async: BOOLEAN): OSErr;
  485. FUNCTION PPCRead(pb: PPCReadPBPtr; async: BOOLEAN): OSErr;
  486. FUNCTION PPCEnd(pb: PPCEndPBPtr; async: BOOLEAN): OSErr;
  487. FUNCTION PPCClose(pb: PPCClosePBPtr; async: BOOLEAN): OSErr;
  488. FUNCTION IPCListPorts(pb: IPCListPortsPBPtr; async: BOOLEAN): OSErr;
  489.  
  490.  
  491. {$ALIGN RESET}
  492. {$POP}
  493.  
  494. {$SETC UsingIncludes := PPCToolboxIncludes}
  495.  
  496. {$ENDC} {__PPCTOOLBOX__}
  497.  
  498. {$IFC NOT UsingIncludes}
  499.  END.
  500. {$ENDC}
  501.